{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-3-5d4f69c667b0>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets('./',one_hot = True)\n",
    "\n",
    "\n",
    "#训练集\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "#验证集\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "#测试集\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4,idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder('float',[None,784],name = 'x')\n",
    "y = tf.placeholder('float',[None,10],name = 'y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x,[-1,28,28,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f84208a1c50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f84208a1c50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f84208a1c50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f84208a1c50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    c1 = tf.contrib.slim.conv2d(\n",
    "        x_image,6,[5,5],padding='VALID',activation_fn = tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a15d90>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a15d90>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a15d90>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a15d90>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    s2 = tf.contrib.slim.max_pool2d(\n",
    "        c1,[2,2],stride = [2,2],padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f8420709410>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f8420709410>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f8420709410>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x7f8420709410>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    c3 = tf.contrib.slim.conv2d(\n",
    "        s2,16,[5,5],padding='VALID',activation_fn = tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a4add0>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a4add0>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a4add0>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x7f8420a4add0>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    s4 = tf.contrib.slim.max_pool2d(\n",
    "        c3,[2,2],stride = [2,2],padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/contrib/layers/python/layers/layers.py:1634: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n",
      "WARNING:tensorflow:Entity <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x7f843c39ab90>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x7f843c39ab90>>: AttributeError: module 'gast' has no attribute 'Num'\n",
      "WARNING: Entity <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x7f843c39ab90>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x7f843c39ab90>>: AttributeError: module 'gast' has no attribute 'Num'\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4b50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4b50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4b50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4b50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4450>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4450>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4450>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f84209d4450>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    s4_flat = tf.contrib.slim.flatten(s4)\n",
    "    c5 = tf.contrib.slim.fully_connected(\n",
    "        s4_flat,120,activation_fn = tf.nn.relu)\n",
    "    \n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(c5,84,activation_fn = tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-e94769b7120e>:3: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f8420a9af50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f8420a9af50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f8420a9af50>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x7f8420a9af50>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name = 'keep_prob',dtype = tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6,keep_prob)\n",
    "    \n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop,10,activation_fn=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-13-968cdd3d58e9>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits = logits,labels = y))\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name,w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss',cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss',l2_loss)\n",
    "tf.summary.scalar('total_loss',total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y,1),tf.argmax(logits,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "training_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps,the loss is 0.37183, the validation accuracy is 0.929\n",
      "after 200 training steps,the loss is 0.150117, the validation accuracy is 0.9568\n",
      "after 300 training steps,the loss is 0.129395, the validation accuracy is 0.9712\n",
      "after 400 training steps,the loss is 0.113037, the validation accuracy is 0.9734\n",
      "after 500 training steps,the loss is 0.0547525, the validation accuracy is 0.9776\n",
      "after 600 training steps,the loss is 0.126962, the validation accuracy is 0.9788\n",
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/training/saver.py:960: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps,the loss is 0.112709, the validation accuracy is 0.9766\n",
      "after 800 training steps,the loss is 0.0431452, the validation accuracy is 0.9808\n",
      "after 900 training steps,the loss is 0.0191752, the validation accuracy is 0.9824\n",
      "after 1000 training steps,the loss is 0.0243429, the validation accuracy is 0.983\n",
      "the training is finish!\n",
      "the test accuracy is: 0.9858\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "    \n",
    "    writer = tf.summary.FileWriter(\"logs/\",sess.graph)\n",
    "    #初始化所有的权重参数\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    #定义验证集和测试集\n",
    "    validate_data = {\n",
    "        x:mnist.validation.images,\n",
    "        y:mnist.validation.labels,\n",
    "        keep_prob:1.0\n",
    "    }\n",
    "    test_data = {x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0}\n",
    "    \n",
    "    for i in range(training_step):\n",
    "        xs,ys = mnist.train.next_batch(batch_size)\n",
    "        _,loss,rs = sess.run(\n",
    "        [optimizer,cross_entropy_loss,merged],\n",
    "        feed_dict={\n",
    "            x:xs,\n",
    "            y:ys,\n",
    "            keep_prob:0.6\n",
    "        })\n",
    "        writer.add_summary(rs,i)\n",
    "        \n",
    "        if i >0 and i%100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy,feed_dict = validate_data)\n",
    "            print(\n",
    "                \"after %d training steps,the loss is %g, the validation accuracy is %g\"%(i,loss,validate_accuracy)\n",
    "            )\n",
    "            saver.save(sess,'./model.ckpt',global_step=i)\n",
    "            \n",
    "    print(\"the training is finish!\")\n",
    "    acc = sess.run(accuracy,feed_dict = test_data)\n",
    "    print(\"the test accuracy is:\",acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/yzf/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow/python/training/saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess,ckpt.model_checkpoint_path)\n",
    "        final_pred,acc = sess.run(\n",
    "        [pred,accuracy],\n",
    "        feed_dict = {\n",
    "            x:mnist.test.images[:16],\n",
    "            y:mnist.test.labels[:16],\n",
    "            keep_prob:1.0\n",
    "        })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8,8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx,:][-1]\n",
    "            prob = final_pred[idx,:][order]\n",
    "            plt.subplot(4,4,idx+1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}:[{}]-[{:.1f}%]'.format(np.argmax(mnist.test.labels[idx]),order,prob*100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28,28)))\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "心得体会：mnist数据集是一个比较适合入门tensorflow的数据集，所有的图片都集中保存在四个扩展名为idx*-ubyte.gz的二进制文件。\n",
    "我们开始进行识别时，首先要下载数据集，然后训练数据集。定义了一个计算图来训练数据，在计算图中对输入输出进行占位和定义，然后进行卷积和池化操作，可以看得出来这里的卷积和池化操作还是比较简单的。上述过程要注意的是第二次池化后将数据输入全连接神经网络，输入的数据是一维的，而池化输出的数据是二维的，这里我们要把数据进行一个flatten将二维数据变换成一维数据输入到全连接神经网络中。完成上述操作之后要处理损失，这里做了交叉熵损失计算以及l2损失，这两个损失以一定系数相加就是整个过程的损失，最后利用梯度下降法对损失进行优化。以上的步骤仅仅是完成了计算图，要使上述过程运行起来得运行整个计算图，在输入数据中，我们要把数据分batch输入，每一个batch是100个数据，这样可以增加运行效率，在训练训练集上的数据的时候，实际上我们把整5500个数据输入了11000次，也就是两个epoch。在这个过程中我认为比较好用的就是saver，可以存储已经跑过的数据，在下一次运行时就不用重跑，这给跑大型数据集带来了很大的便利。\n",
    "tensorboard中提供了一个可视化工具tensorboard，它可以用来展示网络图、张量的指标变化、张量的分布情况等。在这个实例中，可以看到交叉熵损失和l2损失以及最后总的损失的变化过程，也有整个程序的流程图，是一个很直观的工具"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积神经网络和全连接神经网络的区别在于相邻两点之间的节点连接。全连接神经网络是全部连接，卷积神经网络只有部分节点连接。\n",
    "使用全连接神经网络处理图像的不足之处在参数过多。对于MNIST数据，每一张图片的大小是28*28*1，其中28*28是图片的大小，*1表示图像是黑白的，只有一个色彩通道。假设第一层隐藏层的节点数为500个，那么一个全连接层的神经网络将有28*28*500+500=392500个参数。参数过多会导致计算速度慢。再一点，全连接神经网络考虑到了所有的信息，包括噪声，而卷积神经网络中能够使用dropout去噪，防止过拟合。卷积神经网络能够有所侧重，学到关键的特征。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
